home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / shells / zsh-3.000 / zsh-3 / home / ftp / pub / local / info / zsh.info-2 (.txt) < prev    next >
GNU Info File  |  1996-07-16  |  50KB  |  1,007 lines
  1. This is Info file zsh.info, produced by Makeinfo-1.63 from the input
  2. file ./zsh.texi.
  3. This is a texinfo version of the man page for the Z Shell, originally by
  4. Paul Falstad.  It was converted from the `zsh.1' file distributed with
  5. zsh v2.5.0 by Jonathan Hardwick, `jch@cs.cmu.edu' and updated/modified
  6. by Clive Messer, `clive@epos.demon.co.uk' to it's present state.
  7. File: zsh.info,  Node: Modifiers,  Prev: Word Designators,  Up: History Expansion
  8. Modifiers
  9. ---------
  10. After the optional word designator, you can add a sequence of one or
  11. more of the following modifiers, each preceded by a `:'.  These
  12. modifiers also work on the result of filename and parameter expansion.
  13.      Remove a trailing pathname component,  leaving the head.
  14.      Remove a trailing suffix of the form `.xxx', leaving the basename.
  15.      Remove all but the suffix.
  16.      Remove all leading pathname components, leaving the tail.
  17.      Repeat the previous substitution.
  18.      Apply the change to the first occurrence of a match in each word,
  19.      by prefixing the above (for example, `g&').
  20.      Print the new command but do not execute it.
  21.      Quote the substituted words, escaping further substitutions.
  22.      Like `q', but break into words at each blank.
  23.      Convert the words to all lowercase.
  24.      Convert the words to all uppercase.
  25.      Repeats the immediately (without a colon) following modifier until
  26.      the resulting word doesn't change any more.  This and the
  27.      following  `F', `w' and `W' modifier only work with parameter and
  28.      filename expansion.
  29. `F:EXPR:'
  30.      Like `f', but repeats only `n' times if the expression EXPR
  31.      evaluates to `n'. Any character can be used instead of the `:', if
  32.      any of `(', `[', or `{' is used as the opening delimiter the
  33.      second one has to be `)', `]', or `}' respectively.
  34.      Makes the immediately following modifier work on each word in the
  35.      string.
  36. `W:SEP:'
  37.      Like `w' but words are considered to be the parts of the string
  38.      that are separated by SEP.  Any character can be used instead of
  39.      the `:', opening parentheses are handled specially, see above.
  40. `s/L/R[/]'
  41.      Substitute R for L.
  42. Unless preceded by a `g', the substitution is done only  for the first
  43. string that matches `l'.
  44. The left-hand side of substitutions are not regular expressions, but
  45. character strings.  Any character can be used as the delimiter in place
  46. of `/'.  A backslash quotes the delimiter character.  The character
  47. `&', in the right hand side, is replaced by the text from the
  48. left-hand-side.  The `&' can be quoted with a backslash.   A null `l'
  49. uses the previous string either from a `l' or from a contextual scan
  50. string `s' from `!?s'.  You can omit the rightmost delimiter if a
  51. newline immediately follows `r'; the right-most `?' in a context scan
  52. can similarly be omitted.
  53. By default, a history reference with no event specification refers to
  54. the same line as the last history reference on that command line,
  55. unless it is the first history reference in a command.  In that case, a
  56. history reference with no event specification always refers to the
  57. previous command.   However, if the option `CSH_JUNKIE_HISTORY' is set,
  58. then history reference with no event specification will always refer to
  59. the previous command.  For example, `!!:1' will always refer to the
  60. first word of the previous command and `!!$' will always refer to the
  61. last word of the previous command.  And with `CSH_JUNKIE_HISTORY' set,
  62. then `!:1' and `!$' will function in the same manner as `!!:1' and
  63. `!!$', respectively.   However, if `CSH_JUNKIE_HISTORY' is unset, then
  64. `!:1' and `!$' will refer to the first and last words respectively, of
  65. the last command referenced on the current command line.  However, if
  66. they are the first history reference on the command line, then they
  67. refer to the previous command.
  68. The character sequence `^FOO^BAR' repeats the last command, replacing
  69. the string FOO with the string BAR.
  70. If the shell encounters the character sequence `!"' in the input, the
  71. history mechanism is temporarily disabled until the current list is
  72. fully parsed.  The `!"' is removed from the input, and any subsequent
  73. `!' characters have no special significance.
  74. A less convenient but more comprehensible form of command history
  75. support is provided by the `fc' builtin (*note Shell Builtin
  76. Commands::.).
  77. File: zsh.info,  Node: Redirection,  Next: Command Execution,  Prev: Expansion,  Up: Top
  78. Redirection
  79. ***********
  80. Before a command is executed, its input and output may be redirected.
  81. The following may appear anywhere in a simple command or may precede or
  82. follow a complex command.  Substitution occurs before WORD or DIGIT is
  83. used except as noted below.  If the result of substitution on WORD
  84. produces more than one filename, redirection occurs for each separate
  85. filename in turn.
  86. `<WORD'
  87.      Open file WORD as standard input.
  88. `<>WORD'
  89.      Open file WORD for reading and writing as standard input.  If the
  90.      file does not exist then it is created.
  91. `>WORD'
  92.      Open file WORD as standard output.  If the file does not exist
  93.      then it is created.  If the file exists, and the `NO_CLOBBER'
  94.      option is set, this causes an error; otherwise, it is truncated to
  95.      zero length.
  96. `>|WORD'
  97. `>!WORD'
  98.      Same as `>', except that the file is truncated to zero length if it
  99.      exists, even if `NO_CLOBBER' is set.
  100. `>>WORD'
  101.      Open file WORD as standard output.  If the file exists then output
  102.      is appended to it.  If the file does not exist, and the
  103.      `NO_CLOBBER' option is set, this causes an error; otherwise, the
  104.      file is created.
  105. `>>|WORD'
  106. `>>!WORD'
  107.      Same as `>>', except that the file is created if it does not exist,
  108.      even if `NO_CLOBBER' is set.
  109. `<<[-]WORD'
  110.      The shell input is read up to a line that is the same as WORD, or
  111.      to an end-of-file.  No parameter substitution, command
  112.      substitution or filename generation is performed on WORD.  The
  113.      resulting document, called a "here-document", becomes the standard
  114.      input.  If any character of WORD is quoted with single or double
  115.      quotes or a `\', no interpretation is placed upon the characters
  116.      of the document.  Otherwise, parameter and command substitution
  117.      occurs, `\' followed by a newline is removed, and `\' must be used
  118.      to quote the characters `\', `$', ``', and the first character of
  119.      WORD.  If `<<-' is used, then all leading tabs are stripped from
  120.      WORD and from the document.
  121. `<<<WORD'
  122.      Perform shell expansion on WORD and pass the result to standard
  123.      input.
  124. `<&DIGIT'
  125.      The standard input is duplicated from file descriptor DIGIT (see
  126.      `dup(2)').  Similarly for standard output using `>&DIGIT'.
  127. `>&WORD'
  128.      Same as `>WORD 2>&1'.
  129. `>>&WORD'
  130.      Same as `>>WORD 2>&1'.
  131. `<&-'
  132.      Close the standard input.
  133. `>&-'
  134.      Close the standard output.
  135. `<&p'
  136.      The input from the coprocess is moved to the standard input.
  137. `>&p'
  138.      The output to the coprocess is moved to the standard output.
  139. If one of the above is preceded by a digit, then the file descriptor
  140. referred to is that specified by the digit (instead of the default 0 or
  141. 1).  The order in which redirections are specified is significant.  The
  142. shell evaluates each redirection in terms of the (FILE DESCRIPTOR,
  143. FILE) association at the time of evaluation.  For example:
  144.    `... 1>FNAME 2>&1'
  145. first associates file descriptor 1 with file FNAME.  It then associates
  146. file descriptor 2 with the file associated with file descriptor 1 (that
  147. is, FNAME).  If the order of redirections were reversed, file
  148. descriptor 2 would be associated with the terminal (assuming file
  149. descriptor 1 had been) and then file descriptor 1 would be associated
  150. with file FNAME.
  151. If the user tries to open a file descriptor for writing more than once,
  152. the shell opens the file descriptor as a pipe to a process that copies
  153. its input to all the specified outputs, similar to `tee(1)', unless the
  154. `NO_MULTIOS' option is set.  Thus:
  155.    `date >foo >bar'
  156. writes the date to two files, named `foo' and `bar'.  Note that a pipe
  157. is an implicit indirection; thus
  158.    `date >foo | cat'
  159. writes the date to the file `foo', and also pipes it to `cat'.
  160. If the `NO_MULTIOS' option is not set, the word after a redirection
  161. operator is also subjected to filename generation (globbing).  Thus
  162.    `: > *'
  163. will truncate all files in the current directory, assuming there's at
  164. least one.  (With the `NO_MULTIOS' option, it would create an empty
  165. file called `*'.)
  166. If the user tries to open a file descriptor for reading more than once,
  167. the shell opens the file descriptor as a pipe to a process that copies
  168. all the specified inputs to its output in the order specified, similar
  169. to `cat(1)', unless the `NO_MULTIOS' option is set.  Thus
  170.    `sort <foo <fubar'
  171. or even
  172.    `sort <f{oo,ubar}'
  173. is equivalent to `cat foo fubar | sort'.  Similarly, you can do
  174.    `echo exit 0 >> *.sh'
  175.    Note that a pipe is an implicit indirection; thus
  176.    `cat bar | sort <foo'
  177. is equivalent to `cat bar foo | sort' (note the order of the inputs).
  178. If a simple command consists of one or more redirection operators and
  179. zero or more parameter assignments, but no command name, the command
  180. `cat' is assumed.  Thus
  181.    `< file'
  182. prints the contents of `file'.
  183. If a command is followed by `&' and job control is not active, then the
  184. default standard input for the command is the empty file `/dev/null'.
  185. Otherwise, the environment for the execution of a command contains the
  186. file descriptors of the invoking shell as modified by input/output
  187. specifications.
  188. File: zsh.info,  Node: Command Execution,  Next: Functions,  Prev: Redirection,  Up: Top
  189. Command Execution
  190. *****************
  191. If a command name contains no slashes, the shell attempts to locate it.
  192. If there exists a shell function by that name, the function is invoked
  193. as described below (*note Functions::.).  If there exists a shell
  194. builtin by that name, the builtin is invoked.
  195. Otherwise, the shell searches each element of `path' for a directory
  196. containing an executable file by that name.  If the search is
  197. unsuccessful, the shell prints an error message and returns a nonzero
  198. exit status.
  199. If execution fails because the file is not in executable format, and the
  200. file is not a directory, it is assumed to be a shell script.  `/bin/sh'
  201. is spawned to execute it.  If the program is a file beginning with
  202. `#!', the remainder of the first line specifies an interpreter for the
  203. program.  The shell will execute the specified interpreter on operating
  204. systems that do not handle this executable format in the kernel.
  205. File: zsh.info,  Node: Functions,  Next: Jobs & Signals,  Prev: Command Execution,  Up: Top
  206. Functions
  207. *********
  208. The `function' reserved word is used to define shell functions.  Shell
  209. functions are read in and stored internally.  Alias names are resolved
  210. when the function is read.  Functions are executed like commands with
  211. the arguments passed as positional parameters.
  212. Functions execute in the same process as the caller and share all files
  213. and the present working directory with the caller.  A trap on `EXIT'
  214. set inside a function is executed after the function completes in the
  215. environment of the caller.
  216. The `return' builtin is used to return from function calls.
  217. Function identifiers can be listed with the `functions' builtin.
  218. Functions can be undefined with the `unfunction' builtin.
  219. The following functions, if defined, have special meaning to the shell:
  220. `chpwd'
  221.      Executed whenever the current working directory is changed.
  222. `precmd'
  223.      Executed before each prompt.
  224. `periodic'
  225.      If the parameter `PERIOD' is set, this function is executed every
  226.      `PERIOD' seconds, just before a prompt.
  227. `TRAPXXX'
  228.      If defined and non-null, this function will be executed whenever
  229.      the shell catches a signal `SIGXXX', where XXX is a signal name as
  230.      specified for the `kill' builtin (*note Shell Builtin
  231.      Commands::.).  In addition, `TRAPZERR' is executed whenever a
  232.      command has a non-zero exit status, `TRAPDEBUG' is executed after
  233.      each command, and `TRAPEXIT' is executed when the shell exits, or
  234.      when the current function exits if defined inside a function.  If
  235.      a function of this form is defined and null, the shell and
  236.      processes spawned by it will ignore `SIGXXX'.
  237. File: zsh.info,  Node: Jobs & Signals,  Next: Arithmetic Evaluation,  Prev: Functions,  Up: Top
  238. Jobs & Signals
  239. **************
  240. If the `MONITOR' option is set, an interactive shell associates a "job"
  241. with each pipeline.  It keeps a table of current jobs, printed by the
  242. `jobs' command, and assigns them small integer numbers.  When a job is
  243. started asynchronously with `&', the shell prints a line which looks
  244. like:
  245.    `[1] 1234'
  246. indicating that the job which was started asynchronously was job number
  247. 1 and had one (top-level) process, whose process id was 1234.
  248. If a job is started with `&|' or `&!', then that job is immediately
  249. disowned.  After startup, it does not have a place in the job table,
  250. and is not subject to the job control features described here.
  251. If you are running a job and wish to do something else you may hit the
  252. key `^Z' (control-Z) which sends a `TSTP' signal to the current job.
  253. The shell will then normally indicate that the job has been
  254. "suspended", and print another prompt.  You can then manipulate the
  255. state of this job, putting it into the background with the `bg'
  256. command, or run some other commands and then eventually bring the job
  257. back into the foreground with the foreground command `fg'.  A `^Z'
  258. takes effect immediately and is like an interrupt in that pending
  259. output and unread input are discarded when it is typed.
  260. A job being run in the background will suspend if it tries to read from
  261. the terminal.  Background jobs are normally allowed to produce output,
  262. but this can be disabled by giving the command `stty tostop'.  If you
  263. set this tty option, then background jobs will suspend when they try to
  264. produce output, like they do when they try to read input.
  265. There are several ways to refer to jobs in the shell.  A job can be
  266. referred to by the process id of any process of the job or by one of the
  267. following:
  268. `%NUMBER'
  269.      The job with the given number.
  270. `%STRING'
  271.      Any job whose command line begins with STRING.
  272. `%?STRING'
  273.      Any job whose command line contains STRING.
  274.      Current job.
  275.      Equivalent to `%%'.
  276.      Previous job.
  277. The shell learns immediately whenever a process changes state.  It
  278. normally informs you whenever a job becomes blocked so that no further
  279. progress is possible.  If `notify' is not set, it waits until just
  280. before it prints a prompt before it informs you.
  281. When the monitor mode is on, each background job that completes triggers
  282. any trap set for `CHLD'.
  283. When you try to leave the shell while jobs are running or suspended, you
  284. will be warned that `You have suspended (running) jobs'.  You may use
  285. the `jobs' command to see what they are.  If you do this or immediately
  286. try to exit again, the shell will not warn you a second time; the
  287. suspended jobs will be terminated, and the running jobs will be sent a
  288. `SIGHUP' signal.  To avoid having the shell terminate the running jobs,
  289. either use the `nohup(1)' command or the `disown' builtin (*note Shell
  290. Builtin Commands::.).
  291. The `INT' and `QUIT' signals for an invoked command are ignored if the
  292. command is followed by `&' and the job `monitor' option is not active.
  293. Otherwise, signals have the values inherited by the shell from its
  294. parent (but *Note Functions::, for the `TRAPXXX' special functions).
  295. File: zsh.info,  Node: Arithmetic Evaluation,  Next: Conditional Expressions,  Prev: Jobs & Signals,  Up: Top
  296. Arithmetic Evaluation
  297. *********************
  298. An ability to perform integer arithmetic is provided with the builtin
  299. `let'.  Evaluations are performed using *long* arithmetic.  A leading
  300. `0x' or `0X' denotes hexadecimal.  Otherwise, numbers are of the form
  301. `[BASE#]N' where BASE is a decimal number between two and thirty-six
  302. representing the arithmetic base and N is a number in that base (for
  303. example, `16#ff' is 255 in hexadecimal).  If BASE is omitted then base
  304. 10 is used.  For backwards compatibility the form `[16]ff' is also
  305. accepted.
  306. An arithmetic expression uses nearly the same syntax, precedence, and
  307. associativity of expressions in C.  The following operators are
  308. supported (listed in decreasing order of precedence):
  309. `+ - ! ~ ++ --'
  310.      Unary plus/minus, logical NOT, complement, {pre,post}{in,de}crement
  311. `<< >>'
  312.      Bitwise shift left, right.
  313.      Bitwise AND
  314.      Bitwise XOR
  315.      Bitwise OR
  316.      Exponentiation
  317. `* / %'
  318.      Multiplication, division, modulus (remainder)
  319. `+ -'
  320.      Addition, subtraction
  321. `< > <= >='
  322.      Comparison
  323. `== !='
  324.      Equality and inequality
  325.      Logical AND
  326. `|| ^^'
  327.      Logical OR, XOR
  328. `? :'
  329.      Ternary operator
  330. `= += -= *= /= %= &= ^= |= <<= >>= &&= ||= ^^= **='
  331.      Assignment
  332.      Comma operator
  333. The operators `&&', `||', `&&=', and `||=' are short-circuiting, and
  334. only one of the latter two expressions in a ternary operator is
  335. evaluated.  Note the precedence of the bitwise AND, OR, and XOR
  336. operators.
  337. An expression of the form `#\x' where `x' is any character gives the
  338. ASCII value of this character.  An expression of the form `#foo' gives
  339. the ASCII value of the first character of the value of the parameter
  340. `foo'.
  341. Named parameters and subscripted arrays can be referenced by name
  342. within an arithmetic expression without using the parameter
  343. substitution syntax.
  344. An internal integer representation of a named parameter can be specified
  345. with the `integer' builtin.  Arithmetic evaluation is performed on the
  346. value of each assignment to a named parameter declared integer in this
  347. manner.
  348. Since many of the arithmetic operators require quoting, an alternative
  349. form of the `let' command is provided.  For any command which begins
  350. with a `((', all the characters until a matching `))' are treated as a
  351. quoted expression.  More precisely, `(( ... ))' is equivalent to `let
  352. "..."'.
  353. File: zsh.info,  Node: Conditional Expressions,  Next: Zsh Line Editor,  Prev: Arithmetic Evaluation,  Up: Top
  354. Conditional Expressions
  355. ***********************
  356. A "conditional expression" is used with the `[[' compound command to
  357. test attributes of files and to compare strings.  Each expression can
  358. be constructed from one or more of the following unary or binary
  359. expressions:
  360. `-a FILE'
  361.      True if FILE exists.
  362. `-b FILE'
  363.      True if FILE exists and is a block special file.
  364. `-c FILE'
  365.      True if FILE exists and is a character special file.
  366. `-d FILE'
  367.      True if FILE exists and is a directory.
  368. `-e FILE'
  369.      True if FILE exists.
  370. `-f FILE'
  371.      True if FILE exists and is an ordinary file.
  372. `-g FILE'
  373.      True if FILE exists and has its setgid bit set.
  374. `-h FILE'
  375.      True if FILE exists and is a symbolic link.
  376. `-k FILE'
  377.      True if FILE exists and has its sticky bit set.
  378. `-n STRING'
  379.      True if length of STRING is non-zero.
  380. `-o OPTION'
  381.      True if option named OPTION is on.
  382. `-p FILE'
  383.      True if FILE exists and is a FIFO special file or a pipe.
  384. `-r FILE'
  385.      True if FILE exists and is readable by the current process.
  386. `-s FILE'
  387.      True if FILE exists and has size greater than zero.
  388. `-t FD'
  389.      True if file descriptor number FD is open and associated with a
  390.      terminal device (note: FD is not optional).
  391. `-u FILE'
  392.      True if FILE exists and has its setuid bit set.
  393. `-w FILE'
  394.      True if FILE exists and is writable by current process.
  395. `-x FILE'
  396.      True if FILE exists and is executable by current process.  If FILE
  397.      exists and is a directory, then the current process has permission
  398.      to search in the directory.
  399. `-z STRING'
  400.      True if length of STRING is zero.
  401. `-L FILE'
  402.      True if FILE exists and is a symbolic link.
  403. `-O FILE'
  404.      True if FILE exists and is owned by the effective user id of this
  405.      process.
  406. `-G FILE'
  407.      True if FILE exists and its group matches the effective group id
  408.      of this process.
  409. `-S FILE'
  410.      True if FILE exists and is a socket.
  411. `FILE1 -nt FILE2'
  412.      True if FILE1 exists and is newer than FILE2.
  413. `FILE1 -ot FILE2'
  414.      True if FILE1 exists and is older than FILE2.
  415. `FILE1 -ef FILE2'
  416.      True if FILE1 and FILE2 exist and refer to the same file.
  417. `STRING == PATTERN'
  418. `STRING = PATTERN'
  419.      True if STRING matches PATTERN.  The first form is the preferred
  420.      one.  The other form is for backward compatibility and should be
  421.      considered obsolete.
  422. `STRING != PATTERN'
  423.      True if STRING does not match PATTERN.
  424. `STRING1 < STRING2'
  425.      True if STRING1 comes before STRING2 based on ASCII value of their
  426.      characters.
  427. `STRING1 > STRING2'
  428.      True if STRING1 comes after STRING2 based on ASCII value of their
  429.      characters.
  430. `EXP1 -eq EXP2'
  431.      True if EXP1 is equal to EXP2.
  432. `EXP1 -ne EXP2'
  433.      True if EXP1 is not equal to EXP2.
  434. `EXP1 -lt EXP2'
  435.      True if EXP1 is less than EXP2.
  436. `EXP1 -gt EXP2'
  437.      True if EXP1 is greater than EXP2.
  438. `EXP1 -le EXP2'
  439.      True if EXP1 is less than or equal to EXP2.
  440. `EXP1 -ge EXP2'
  441.      True if EXP1 is greater than or equal to EXP2.
  442. `( EXP )'
  443.      True if EXP is true.
  444. `! EXP'
  445.      True if EXP is false.
  446. `EXP1 && EXP2'
  447.      True if EXP1 and EXP2 are both true.
  448. `EXP1 || EXP2'
  449.      True if either EXP1 or EXP2 is true.
  450. In each of the above expressions, if FILE is of the form `/dev/fd/N',
  451. where N is an integer, then the test is applied to the open file whose
  452. descriptor number is N, even if the underlying system does not support
  453. the `/dev/fd' directory.
  454. File: zsh.info,  Node: Zsh Line Editor,  Next: Parameters,  Prev: Conditional Expressions,  Up: Top
  455. Zsh Line Editor
  456. ***************
  457. If the `ZLE' option is set (it is by default) and the shell input is
  458. attached to the terminal, the user is allowed to edit command lines.
  459. There are two display modes.  The first, multi-line mode, is the
  460. default.  It only works if the `TERM' parameter is set to a valid
  461. terminal type that can move the cursor up.  The second, single line
  462. mode, is used if `TERM' is invalid or incapable of moving the cursor
  463. up, or if the `SINGLE_LINE_ZLE' option is set.  This mode is similar to
  464. ksh, and uses no termcap sequences.  If `TERM' is `emacs', the `ZLE'
  465. option will be unset by the shell.
  466. Bindings
  467. ========
  468. Command bindings may be set using the `bindkey' builtin.  There are two
  469. keymaps; the main keymap and the alternate keymap.  The alternate
  470. keymap is bound to vi command mode.  The main keymap is bound to emacs
  471. mode by default.  To bind the main keymap to vi insert mode, use
  472. `bindkey -v'.  However, if either of the `VISUAL' or `EDITOR'
  473. environment variables contains the string `vi' when the shell starts up
  474. the main keymap will be bound to vi insert mode by default.
  475. The following is a list of all the key commands and their default
  476. bindings in emacs mode, vi command mode and vi insert mode.
  477. * Menu:
  478. * Movement::
  479. * History Control::
  480. * Modifying Text::
  481. * Arguments::
  482. * Completion::
  483. * Miscellaneous::
  484. File: zsh.info,  Node: Movement,  Next: History Control,  Up: Zsh Line Editor
  485. Movement
  486. ========
  487. `vi-backward-blank-word (unbound) (`B') (unbound)'
  488.      Move backward one word, where a word is defined as a series of
  489.      non-blank characters.
  490. `backward-char (`^B' `ESC-[D') (unbound)'
  491.      Move backward one character.
  492. `vi-backward-char (unbound) (`^H' `h' `^?') (unbound)'
  493.      Move backward one character, without changing lines.
  494. `backward-word (`ESC-B' `ESC-b') (unbound) (unbound)'
  495.      Move to the beginning of the previous word.
  496. `emacs-backward-word'
  497.      Move to the beginning of the previous word.
  498. `vi-backward-word (unbound) (`b') (unbound)'
  499.      Move to the beginning of the previous word, vi-style.
  500. `beginning-of-line (`^A') (unbound) (unbound)'
  501.      Move to the beginning of the line.  If already at the beginning of
  502.      the line, move to the beginning of the previous line, if any.
  503. `vi-beginning-of-line'
  504.      Move to the beginning of the line, without changing lines.
  505. `end-of-line (`^E') (unbound) (unbound)'
  506.      Move to the end of the line.  If already at the end of the line,
  507.      move to the end of the next line, if any.
  508. `vi-end-of-line (unbound) (`$') (unbound)'
  509.      Move to the end of the line.  If an argument is given to this
  510.      command, the cursor will be moved to the end of the line (argument
  511.      - 1) lines down.
  512. `vi-forward-blank-word (unbound) (`W') (unbound)'
  513.      Move forward one word, where a word is defined as a series of
  514.      non-blank characters.
  515. `vi-forward-blank-word-end (unbound) (`E') (unbound)'
  516.      Move to the end of the current word, or, if at the end of the
  517.      current word, to the end of the next word, where a word is defined
  518.      as a series of non-blank characters.
  519. `forward-char (`^F' `ESC-[C') (unbound) (unbound)'
  520.      Move forward one character.
  521. `vi-forward-char (unbound) (SPACE `l') (unbound)'
  522.      Move forward one character.
  523. `vi-find-next-char (`^X^F') (`f') (unbound)'
  524.      Read a character from the keyboard, and move to the next
  525.      occurrence of it in the line.
  526. `vi-find-next-char-skip (unbound) (`t') (unbound)'
  527.      Read a character from the keyboard, and move to the position just
  528.      before the next occurrence of it in the line.
  529. `vi-find-prev-char (unbound) (`F') (unbound)'
  530.      Read a character from the keyboard, and move to the previous
  531.      occurrence of it in the line.
  532. `vi-find-prev-char-skip (unbound) (`T') (unbound)'
  533.      Read a character from the keyboard, and move to the position just
  534.      after the previous occurrence of it in the line.
  535. `vi-first-non-blank (unbound) (`^') (unbound)'
  536.      Move to the first non-blank character in the line.
  537. `vi-forward-word (unbound) (`w') (unbound)'
  538.      Move forward one word, vi-style.
  539. `forward-word (`ESC-F' `ESC-f') (unbound) (unbound)'
  540.      Move to the beginning of the next word.  The editor's idea of a
  541.      word is specified with the `WORDCHARS' parameter.
  542. `emacs-forward-word'
  543.      Move to the end of the next word.
  544. `vi-forward-word-end (unbound) (`e') (unbound)'
  545.      Move to the end of the next word.
  546. `vi-goto-column (`ESC-|') (`|') (unbound)'
  547.      Move to the column specified by the numeric argument.
  548. `vi-goto-mark (unbound) (``') (unbound)'
  549.      Move to the specified mark.
  550. `vi-goto-mark-line (unbound) (`'') (unbound)'
  551.      Move to the beginning of the line containing the specified mark.
  552. `vi-repeat-find (unbound) (`;') (unbound)'
  553.      Repeat the last `vi-find' command.
  554. `vi-rev-repeat-find (unbound) (`,') (unbound)'
  555.      Repeat the last `vi-find' command in the opposite direction.
  556. File: zsh.info,  Node: History Control,  Next: Modifying Text,  Prev: Movement,  Up: Zsh Line Editor
  557. History Control
  558. ===============
  559. `beginning-of-buffer-or-history (`ESC-<') (unbound) (unbound)'
  560.      Move to the beginning of the buffer, or if already there, move to
  561.      the first event in the history list.
  562. `beginning-of-line-hist'
  563.      Move to the beginning of the line.  If already at the beginning of
  564.      the buffer, move to the previous history line.
  565. `beginning-of-history'
  566.      Move to the first event in the history list.
  567. `down-line-or-history (`^N' `ESC-[B') (`j') (unbound)'
  568.      Move down a line in the buffer, or if already at the bottom line,
  569.      move to the next event in the history list.
  570. `vi-down-line-or-history (unbound) (`+') (unbound)'
  571.      Move down a line in the buffer, or if already at the bottom line,
  572.      move to the next event in the history list.  Then move to the
  573.      first non-blank character on the line.
  574. `down-line-or-search'
  575.      Move down a line in the buffer, or if already at the bottom line,
  576.      search forward in the history for a line beginning with the first
  577.      word in the buffer.
  578. `down-history (unbound) (`^N') (unbound)'
  579.      Move to the next event in the history list.
  580. `history-beginning-search-backward'
  581.      Search backward in the history for a line beginning with the
  582.      current line up to the cursor.  This leaves the cursor in its
  583.      original position.
  584. `end-of-buffer-or-history (`ESC->') (unbound) (unbound)'
  585.      Move to the end of the buffer, or if already there, move to the
  586.      last event in the history list.
  587. `end-of-line-hist'
  588.      Move to the end of the line.  If already at the end of the buffer,
  589.      move to the next history line.
  590. `end-of-history'
  591.      Move to the last event in the history list.
  592. `vi-fetch-history (unbound) (`G') (unbound)'
  593.      Fetch the history line specified by the numeric argument.  This
  594.      defaults to the current history line (i.e. the one that isn't
  595.      history yet).
  596. `history-incremental-search-backward (`^R' `^Xr') (unbound) (unbound)'
  597.      Search backward incrementally for a specified string.  The string
  598.      may begin with `^' to anchor the search to the beginning of the
  599.      line.  A restricted set of editing functions is available in the
  600.      mini-buffer.  An interrupt signal, as defined by the stty setting,
  601.      will stop the search and go back to the original line.  An
  602.      undefined key will have the same effect.  The supported functions
  603.      are: `backward-delete-char', `vi-backward-delete-character',
  604.      `clearscreen', `redisplay', `quoted-insert', `vi-quoted-insert',
  605.      `accept-and-hold', `accept-and-infer-next-history', `accept-line'
  606.      and `accept-line-and-down-history'; `magic-space' just inserts a
  607.      space.  `vi-cmd-mode' toggles between the main and alternate key
  608.      bindings; the main key bindings (insert mode) will be selected
  609.      initially.  Any string that is bound to an out-string (via
  610.      `bindkey -s') will behave as if out-string were typed directly.
  611.      Typing the binding of `history-incremental-search-backward' will
  612.      get the next occurrence of the contents of the mini-buffer.
  613.      Typing the binding of `history-incremental-search-forward' inverts
  614.      the sense of the search.  The direction of the search is indicated
  615.      in the mini-buffer.  Any single character that is not bound to one
  616.      of the above functions, or `self-insert' or `self-insert-unmeta'
  617.      will have the same effect but the function will be executed.
  618. `history-incremental-search-forward (`^S' `^Xs') (unbound) (unbound)'
  619.      Search forward incrementally for a specified string.  The string
  620.      may begin with `^' to anchor the search to the beginning of the
  621.      line.  The functions available in the mini-buffer are the same as
  622.      for `history-incremental-search-backward'.
  623. `history-search-backward (`ESC-P' `ESC-p') (unbound) (unbound)'
  624.      Search backward in the history for a line beginning with the first
  625.      word in the buffer.
  626. `vi-history-search-backward (unbound) (`/') (unbound)'
  627.      Search backward in the history for a specified string.  The string
  628.      may begin with `^' to anchor the search to the beginning of the
  629.      line.  A restricted set of editing functions is available in the
  630.      mini-buffer.  An interrupt signal, as defined by the stty setting,
  631.      will stop the search.  The functions available in the mini-buffer
  632.      are: `accept-line', `vi-cmd-mode' (treated the same as
  633.      `acceptline'), `backward-delete-char', `vi-backward-delete-char',
  634.      `backward-kill-word', `vi-backward-kill-word', `clear-screen',
  635.      `redisplay', `magic-space' (treated as a space), `quoted-insert'
  636.      and `vi-quoted-insert'.  Any string that is not bound to an
  637.      out-string (via `bindkey -s') will behave as if out-string were
  638.      typed directly. Any other character that is not bound to
  639.      `self-insert' or `self-insert-unmeta' will beep and be ignored.  If
  640.      the function is called from vi command mode, the bindings of the
  641.      current insert mode will be used.
  642. `history-search-forward (`ESC-N' `ESC-n') (unbound) (unbound)'
  643.      Search forward in the history for a line beginning with the first
  644.      word in the buffer.
  645. `vi-history-search-forward (unbound) (`?') (unbound)'
  646.      Search forward in the history for a specified string.  The string
  647.      may begin with `^' to anchor the search to the beginning of the
  648.      line.  The functions available in the mini-buffer are the same as
  649.      for `vi-history-search-backward'.
  650. `infer-next-history (`^X^N') (unbound) (unbound)'
  651.      Search in the history for a line matching the current one and
  652.      fetch the event following it.
  653. `insert-last-word (`ESC-_' `ESC-.') (unbound) (unbound)'
  654.      Insert the last word from the previous history event at the cursor
  655.      position.
  656. `vi-repeat-search (unbound) (`n') (unbound)'
  657.      Repeat the last vi history search.
  658. `vi-rev-repeat-search (unbound) (`N') (unbound)'
  659.      Repeat the last vi history search, but in reverse.
  660. `up-line-or-history (`^P' `ESC-[A') (`k') (unbound)'
  661.      Move up a line in the buffer, or if already at the top line, move
  662.      to the previous event in the history list.
  663. `up-line-or-search'
  664.      Move up a line in the buffer, or if already at the top line, search
  665.      backward in the history for a line beginning with the first word
  666.      in the buffer.
  667. `up-history (unbound) (`^P') (unbound)'
  668.      Move to the previous event in the history list.
  669. `history-beginning-search-forward'
  670.      Search forward in the history for a line beginning with the
  671.      current line up to the cursor.  This leaves the cursor at its
  672.      original position.
  673. File: zsh.info,  Node: Modifying Text,  Next: Arguments,  Prev: History Control,  Up: Zsh Line Editor
  674. Modifying Text
  675. ==============
  676. `vi-add-eol (unbound) (`A') (unbound)'
  677.      Move to the end of the line and enter insert mode.
  678. `vi-add-next (unbound) (`a') (unbound)'
  679.      Enter insert mode after the current cursor position, without
  680.      changing lines.
  681. `backward-delete-char (`^H' `^?') (unbound) (unbound)'
  682.      Delete the character behind the cursor.
  683. `vi-backward-delete-char (unbound) (`X') (`^H')'
  684.      Delete the character behind the cursor, without changing lines.
  685.      If in insert mode this won't delete past the point where insert
  686.      mode was last entered.
  687. `backward-delete-word'
  688.      Delete the word behind the cursor.
  689. `backward-kill-line'
  690.      Kill from the beginning of the line to the cursor position.
  691. `backward-kill-word (`^W' `ESC-^H' `ESC-^?') (unbound) (unbound)'
  692.      Kill the word behind the cursor.
  693. `vi-backward-kill-word (unbound) (unbound) (`^W')'
  694.      Kill the word behind the cursor, without going past the point
  695.      where insert mode was last entered.
  696. `capitalize-word (`ESC-C' `ESC-c') (unbound) (unbound)'
  697.      Capitalize the current word and move past it.
  698. `vi-change (unbound) (`c') (unbound)'
  699.      Read a movement command from the keyboard, and kill from the cursor
  700.      position to the endpoint of the movement.  Then enter insert mode.
  701.      If the command is `vi-change', kill the current line.
  702. `vi-change-eol (unbound) (`C') (unbound)'
  703.      Kill to the end of the line and enter insert mode.
  704. `vi-change-whole-line (unbound) (`S') (unbound)'
  705.      Kill the current line and enter insert mode.
  706. `copy-region-as-kill (`ESC-W' `ESC-w') (unbound) (unbound)'
  707.      Copy the area from the cursor to the mark to the kill buffer.
  708. `copy-prev-word (`ESC-^_') (unbound) (unbound)'
  709.      Duplicate the word behind the cursor.
  710. `vi-delete (unbound) (`d') (unbound)'
  711.      Read a movement command from the keyboard, and kill from the cursor
  712.      position to the endpoint of the movement.  If the command is
  713.      `vi-delete', kill the current line.
  714. `delete-char'
  715.      Delete the character under the cursor.
  716. `vi-delete-char (unbound) (`x') (unbound)'
  717.      Delete the character under the cursor, without going past the end
  718.      of the line.
  719. `delete-word'
  720.      Delete the current word.
  721. `down-case-word (`ESC-L' `ESC-l') (unbound) (unbound)'
  722.      Convert the current word to all lowercase and move past it.
  723. `kill-word (`ESC-D' `ESC-d') (unbound) (unbound)'
  724.      Kill the current word.
  725. `gosmacs-transpose-chars'
  726.      Exchange the two characters behind the cursor.
  727. `vi-indent (unbound) (`>') (unbound)'
  728.      Indent a number of lines.
  729. `vi-insert (unbound) (`i') (unbound)'
  730.      Enter insert mode.
  731. `vi-insert-bol (unbound) (`I') (unbound)'
  732.      Move to the beginning of the line and enter insert mode.
  733. `vi-join (`^X^J') (`J') (unbound)'
  734.      Join the current line with the next one.
  735. `kill-line (`^K') (unbound) (unbound)'
  736.      Kill from the cursor to the end of the line.
  737. `vi-kill-line (unbound) (unbound) (`^U')'
  738.      Kill from the cursor back to wherever insert mode was last entered.
  739. `vi-kill-eol (unbound) (`D') (unbound)'
  740.      Kill from the cursor to the end of the line.
  741. `kill-region'
  742.      Kill from the cursor to the mark.
  743. `kill-buffer (`^X^K') (unbound) (unbound)'
  744.      Kill the entire buffer.
  745. `kill-whole-line (`^U') (unbound) (unbound)'
  746.      Kill the current line.
  747. `vi-match-bracket (`^X^B') (`%') (unbound)'
  748.      Move to the bracket character (one of `{}', `()', or `[]') that
  749.      matches the one under the cursor.  If the cursor is not on a
  750.      bracket character, move forward without going past the end of the
  751.      line to find one, and then go to the matching bracket.
  752. `vi-open-line-above (unbound) (`O') (unbound)'
  753.      Open a line above the cursor and enter insert mode.
  754. `vi-open-line-below (unbound) (`o') (unbound)'
  755.      Open a line below the cursor and enter insert mode.
  756. `vi-oper-swap-case'
  757.      Read a movement command from the keyboard, and swap the case of all
  758.      characters from the cursor position to the endpoint of the
  759.      movement.  If the movement command is `vi-oper-swap-case', swap
  760.      the case of all characters on the current line.
  761. `overwrite-mode (`^X^O') (unbound) (unbound)'
  762.      Toggle between overwrite mode and insert mode.
  763. `vi-put-before (unbound) (`P') (unbound)'
  764.      Insert the contents of the kill buffer before the cursor.  If the
  765.      kill buffer contains a sequence of lines (as opposed to
  766.      characters), paste it above the current line.
  767. `vi-put-after (unbound) (`p') (unbound)'
  768.      Insert the contents of the kill buffer after the cursor.  If the
  769.      kill buffer contains a sequence of lines (as opposed to
  770.      characters), paste it below the current line.
  771. `quoted-insert (`^V') (unbound) (unbound)'
  772.      Insert the next character typed into the buffer literally.  An
  773.      interrupt character will not be inserted.
  774. `vi-quoted-insert (unbound) (unbound) (`^Q' `^V')'
  775.      Display a `^' at the current position, and insert the next
  776.      character typed into the buffer literally.  A `NUL' character will
  777.      be rejected with a beep, requiring a non-`NUL' keypress to
  778.      continue.  An interrupt character will not be inserted.
  779. `quote-line (`ESC-'') (unbound) (unbound)'
  780.      Quote the current line; that is, put a `'' character at the
  781.      beginning and the end, and convert all `'' characters to `\''.
  782. `quote-region (`ESC-"') (unbound) (unbound)'
  783.      Quote the region from the cursor to the mark.
  784. `vi-replace (unbound) (`R') (unbound)'
  785.      Enter overwrite mode.
  786. `vi-repeat-change (unbound) (`.') (unbound)'
  787.      Repeat the last vi mode text modification.  If a count was used
  788.      with the modification, it is remembered.  If a count is given to
  789.      this command, it overrides the remembered count, and is remembered
  790.      for future uses of this command.  The cut buffer specification is
  791.      similarly remembered.
  792. `vi-replace-chars (unbound) (`r') (unbound)'
  793.      Replace the character under the cursor with a character read from
  794.      the keyboard.
  795. `self-insert (printable characters) (unbound) (printable characters and some control characters)'
  796.      Put a character in the buffer at the cursor position.
  797. `self-insert-unmeta (`ESC-^I' `ESC-^J' `ESC-^M') (unbound) (unbound)'
  798.      Put a character in the buffer after stripping the meta bit and
  799.      converting `^M' to `^J'.
  800. `vi-substitute (unbound) (`s') (unbound)'
  801.      Substitute the next character(s).
  802. `vi-swap-case (unbound) (`~') (unbound)'
  803.      Swap the case of the character under the cursor and move past it.
  804. `transpose-chars (`^T') (unbound) (unbound)'
  805.      Exchange the two characters to the left of the cursor if at end of
  806.      line, else exchange the character under the cursor with the
  807.      character to the left.
  808. `transpose-words (`ESC-T' `ESC-t')  (unbound) (unbound)'
  809.      Exchange the current word with the one before it.
  810. `vi-unindent (unbound) (`<') (unbound)'
  811.      Unindent a number of lines.
  812. `up-case-word (`ESC-U' `ESC-u') (unbound) (unbound)'
  813.      Convert the current word to all caps and move past it.
  814. `yank (`^Y') (unbound) (unbound)'
  815.      Insert the contents of the kill buffer at the cursor position.
  816. `yank-pop (`ESC-y') (unbound) (unbound)'
  817.      Remove the text just yanked, rotate the kill-ring, and yank the
  818.      new top.  Only works following `yank' or `yank-pop'.
  819. `vi-yank (unbound) (`y') (unbound)'
  820.      Read a movement command from the keyboard, and copy the region
  821.      from the cursor position to the endpoint of the movement into the
  822.      kill buffer.  If the command is `vi-yank', copy the current line.
  823. `vi-yank-whole-line (unbound) (`Y') (unbound)'
  824.      Copy the current line into the kill buffer.
  825. `vi-yank-eol'
  826.      Copy the region from the cursor position to the end of the line
  827.      into the kill buffer.  Arguably, this is what `Y' should do in vi,
  828.      but it isn't what it actually does.
  829. File: zsh.info,  Node: Arguments,  Next: Completion,  Prev: Modifying Text,  Up: Zsh Line Editor
  830. Arguments
  831. =========
  832. `digit-argument (`ESC-0'...`ESC-9') (1-9) (unbound)'
  833.      Start a new numeric argument, or add to the current one.  See also
  834.      `vi-digit-or-beginning-of-line'.
  835. `neg-argument (`ESC--') (unbound) (unbound)'
  836.      Changes the sign of the following argument.
  837. `universal-argument'
  838.      Multiply the argument of the next command by 4.
  839. File: zsh.info,  Node: Completion,  Next: Miscellaneous,  Prev: Arguments,  Up: Zsh Line Editor
  840. Completion
  841. ==========
  842. `accept-and-menu-complete'
  843.      In a menu completion, insert the current completion into the
  844.      buffer, and advance to the next possible completion.
  845. `complete-word'
  846.      Attempt completion on the current word.
  847. `delete-char-or-list (`^D') (unbound) (unbound)'
  848.      Delete the character under the cursor.  If the cursor is at the
  849.      end of the line, list possible completions for the current word.
  850. `expand-cmd-path'
  851.      Expand the current command to it's full pathname.
  852. `expand-or-complete (TAB) (unbound) (TAB)'
  853.      Attempt shell expansion on the current word.  If that fails,
  854.      attempt completion.
  855. `expand-or-complete-prefix'
  856.      Attempt shell expansion on the current word up to cursor.
  857. `expand-history (`ESC-SPACE' `ESC-!') (unbound) (unbound)'
  858.      Perform history expansion on the edit buffer.
  859. `expand-word (`^X*') (unbound) (unbound)'
  860.      Attempt shell expansion on the current word.
  861. `list-choices (`ESC-^D') (`^D=') (`^D')'
  862.      List possible completions for the current word.
  863. `list-expand (`^Xg' `^XG') (`^G') (`^G')'
  864.      List the expansion of the current word.
  865. `magic-space'
  866.      Perform history expansion and insert a space into the buffer.
  867.      This is intended to be bound to SPACE.
  868. `menu-complete'
  869.      Like `complete-word', except that menu completion is used.  *Note
  870.      Options::, for the `MENU_COMPLETE' option.
  871. `menu-expand-or-complete'
  872.      Like `expand-or-complete', except that menu completion is used.
  873. `reverse-menu-complete'
  874.      *Note Options::, for the `MENU_COMPLETE' option.
  875. File: zsh.info,  Node: Miscellaneous,  Prev: Completion,  Up: Zsh Line Editor
  876. Miscellaneous
  877. =============
  878. `accept-and-hold (`ESC-A' `ESC-a') (unbound) (unbound)'
  879.      Push the contents of the buffer on the buffer stack and execute it.
  880. `accept-and-infer-next-history'
  881.      Execute the contents of the buffer.  Then search the history list
  882.      for a line matching the current one and push the event following
  883.      onto the buffer stack.
  884. `accept-line (`^J' `^M') (`^J' `^M') (`^J' `^M')'
  885.      Execute the contents of the buffer.
  886. `accept-line-and-down-history (`^O') (unbound) (unbound)'
  887.      Execute the current line, and push the next history event on the
  888.      the buffer stack.
  889. `vi-cmd-mode (`^X^V') (unbound) (`^[')'
  890.      Enter command mode; that is, use the alternate keymap.  Yes, this
  891.      is bound by default in emacs mode.
  892. `vi-caps-lock-panic'
  893.      Hang until any lowercase key is pressed.  This is for vi users
  894.      without the mental capacity to keep track of their caps lock key
  895.      (like the author).
  896. `clear-screen (`^L' `ESC-^L') (`^L') (`^L')'
  897.      Clear the screen and redraw the prompt.
  898. `describe-key-briefly'
  899.      Waits for keypress, then prints the function bound to the pressed
  900.      key.
  901. `exchange-point-and-mark (`^X^X') (unbound) (unbound)'
  902.      Exchange the cursor position with the position of the mark.
  903. `execute-named-cmd (`ESC-x') (unbound) (unbound)'
  904.      Read the name of a editor command and execute it.  A restricted
  905.      set of editing functions is available in the mini-buffer.  An
  906.      interrupt signal, as defined by the stty setting, will abort the
  907.      function.  The allowed functions are: `backward-delete-char',
  908.      `vi-backward-delete-char', `clear-screen', `redisplay',
  909.      `quoted-insert', `vi-quoted-insert', `kill-region' (kills the last
  910.      word), `backward-kill-word', `vi-backward-kill-word',
  911.      `kill-whole-line', `vi-kill-line', `backward-kill-line',
  912.      `list-choices', `delete-char-or-list', `complete-word',
  913.      `expand-or-complete', `expand-or-complete-prefix', `accept-line',
  914.      and `vi-cmd-mode' (treated the same as accept line).  The SPC and
  915.      TAB characters, if not bound to one of these functions, will
  916.      complete the name and then list the possibilities if the
  917.      `AUTO_LIST' option is set.  Any string that is bound to an
  918.      out-string (via `bindkey -s') will behave as if out-string were
  919.      typed directly.  Any other character that is not bound to
  920.      `self-insert' or `self-insert-unmeta' will beep and be ignored.
  921.      If the function is called from vi command mode, the bindings of
  922.      the current insert mode will be used.
  923. `execute-last-named-cmd (`ESC-z') (unbound) (unbound)'
  924.      Redo the last function executed with `execute-named-cmd'.
  925. `get-line (`ESC-G' `ESC-g') (unbound) (unbound)'
  926.      Pop the top line off the buffer stack and insert it at the cursor
  927.      position.
  928. `pound-insert (unbound) (`#') (unbound)'
  929.      If there is no `#' character at the beginning of the buffer, add
  930.      one to the beginning of each line.  If there is one, remove a `#'
  931.      from each line that has one.  In either case, accept the current
  932.      line.  The `INTERACTIVE_COMMENTS' option must be set for this to
  933.      have any usefulness.
  934. `vi-pound-insert'
  935.      If there is no `#' character at the beginning of the current line,
  936.      add one.  If there is one, remove it.  The `INTERACTIVE_COMMENTS'
  937.      option must be set for this to have any usefulness.
  938. `push-input'
  939.      Push the entire current multi-line construct onto the buffer stack
  940.      and return to the top-level (`PS1') prompt.  If the current parser
  941.      construct is only a single line, this is exactly like `push-line'.
  942.      Next time the editor starts up or is popped with `get-line', the
  943.      construct will be popped off the top of the buffer stack and
  944.      loaded into the editing buffer.
  945. `push-line (`^Q' `ESC-Q' `ESC-q') (unbound) (unbound)'
  946.      Push the current buffer onto the buffer stack and clear the buffer.
  947.      Next time the editor starts up, the buffer will be popped off the
  948.      top of the buffer stack and loaded into the editing buffer.
  949. `push-line-or-edit'
  950.      At the top-level (`PS1') prompt, equivalent to `push-line'.  At a
  951.      secondary (`PS2') prompt, move the entire current multi-line
  952.      construct into the editor buffer.  The latter is equivalent to
  953.      `push-line' followed by `get-line'.
  954. `redisplay (unbound) (`^R') (`^R')'
  955.      Redisplays the edit buffer.
  956. `send-break (`^G' `ESC-^G') (unbound) (unbound)'
  957.      Abort the current editor function, e.g. `execute-named-command', or
  958.      the editor itself, e.g. if you are in `vared'.  Otherwise abort the
  959.      parsing of the current line.
  960. `run-help (`ESC-H' `ESC-h') (unbound) (unbound)'
  961.      Push the buffer onto the buffer stack, and execute the command
  962.      `run-help CMD', where CMD is the current command.  `run-help' is
  963.      normally aliased to `man'.
  964. `vi-set-buffer (unbound) (`"') (unbound)'
  965.      Specify a buffer to be used in the following command.
  966. `vi-set-mark (unbound) (`m') (unbound)'
  967.      Set the specified mark at the cursor position.
  968. `set-mark-command (`^@') (unbound) (unbound)'
  969.      Set the mark at the cursor position.
  970. `spell-word (`ESC-$' `ESC-S' `ESC-s') (unbound) (unbound)'
  971.      Attempt spelling correction on the current word.
  972. `undefined-key (lots o' keys) (lots o' keys) (unbound)'
  973.      Beep.
  974. `undo (`^_' `^Xu' `^X^U') (unbound) (unbound)'
  975.      Incrementally undo the last text modification.
  976. `vi-undo-change (unbound) (`u') (unbound)'
  977.      Undo the last text modification.  If repeated, redo the
  978.      modification.
  979. `where-is'
  980.      Read the name of an editor command and and print the listing of
  981.      key sequences that invoke the specified command.
  982. `which-command (`ESC-?') (unbound) (unbound)'
  983.      Push the buffer onto the buffer stack, and execute the command
  984.      `which-command CMD', where CMD is the current command.
  985.      `which-command' is normally aliased to `whence'.
  986. `vi-digit-or-beginning-of-line(unbound) (`0') (unbound)'
  987.      If the last command executed was a digit as part of an argument,
  988.      continue the argument.  Otherwise, execute `vi-beginning-of-line'.
  989. File: zsh.info,  Node: Parameters,  Next: Options,  Prev: Zsh Line Editor,  Up: Top
  990. Parameters
  991. **********
  992. A parameter has a name, a value, and a number of attributes.  A name may
  993. be any sequence of alphanumeric characters and `_''s, or the single
  994. characters `*', `@', `#', `?', `-', `$', or `!'.  The value may be
  995. either a scalar (a string), an integer, or an array.  To assign a
  996. scalar or integer value to a parameter, use the `typeset' builtin.  To
  997. assign an array value, use `set -A NAME VALUE ...'.  The value of a
  998. parameter may also be assigned by writing:
  999.    `NAME=VALUE ...'
  1000. If the integer attribute, `-i', is set for NAME, the VALUE is subject
  1001. to arithmetic evaluation.
  1002. * Menu:
  1003. * Array Parameters::
  1004. * Positional Parameters::
  1005. * Parameters Set By The Shell::
  1006. * Parameters Used By The Shell::
  1007.